// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.quality.check.storage;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.QualityCheckStorage;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(QualityCheckStorage.class)
@Setter
@Getter
public class QualityCheckStorageSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "QualityCheckStorage".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("productName", "p");
    map.put("shop", "si");
    map.put("purchaseCode", "po");
    map.put("buyerName", "su");
    map.put("receiveName", "su2");
    map.put("warehouse", "w");
    map.put("supplier", "s");
    map.put("qcName", "su3");
    map.put("whbCodeGoodId", "wb");
    map.put("whbCodeBadId", "wb2");
    map.put("receiptProductId", "rp");
    map.put("waitInspection", "wb3");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：QualityCheckStorage/AllQualityCheck, QualityCheckStorage/Qualitying, QualityCheckStorage/Approval, QualityCheckStorage/Completed, QualityCheckStorage/Revoked
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 质检单号(模糊搜索)
   */
  private String qcSn;

  /**
   * 质检单号 比较(eq)
   */
  private String qcSnEq;
  /**
   * 质检单号 比较(neq)
   */
  private String qcSnNeq;
  /**
   * 质检单号 比较(gt)
   */
  private String qcSnGt;
  /**
   * 质检单号 比较(gte)
   */
  private String qcSnGte;
  /**
   * 质检单号 比较(lt)
   */
  private String qcSnLt;
  /**
   * 质检单号 比较(lte)
   */
  private String qcSnLte;
  /**
   * 质检单号 比较(contains)
   */
  private String qcSnContains;
  /**
   * 质检单号 比较(notcontains)
   */
  private String qcSnNotcontains;
  /**
   * 质检单号 比较(startswith)
   */
  private String qcSnStartswith;
  /**
   * 质检单号 比较(endswith)
   */
  private String qcSnEndswith;
  /**
   * 质检单号 比较(isnull)
   */
  private Boolean qcSnIsnull;
  /**
   * 质检单号 比较(isnotnull)
   */
  private Boolean qcSnIsnotnull;

  /**
   * 质检单号(精确搜索)
   */
  private List<String> qcSnInList;

  /**
   * 是否有 图片
   */
  private Boolean productImg;

  /**
   * 品名
   */
  private Long productName;

  /**
   * 品名 比较(eq)
   */
  private Long productNameEq;
  /**
   * 品名 比较(neq)
   */
  private Long productNameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long productNameGt;
  /**
   * 品名 比较(gte)
   */
  private Long productNameGte;
  /**
   * 品名 比较(lt)
   */
  private Long productNameLt;
  /**
   * 品名 比较(lte)
   */
  private Long productNameLte;
  /**
   * 品名 比较(contains)
   */
  private Long productNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long productNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long productNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long productNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String productNameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String productNameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String productNameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String productNameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String productNameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String productNameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String productNameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String productNameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String productNameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String productNameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean productNameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean productNameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> productNameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 店铺
   */
  private Long shop;

  /**
   * 店铺 比较(eq)
   */
  private Long shopEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * 采购单号
   */
  private Long purchaseCode;

  /**
   * 采购单号 比较(eq)
   */
  private Long purchaseCodeEq;
  /**
   * 采购单号 比较(neq)
   */
  private Long purchaseCodeNeq;
  /**
   * 采购单号 比较(gt)
   */
  private Long purchaseCodeGt;
  /**
   * 采购单号 比较(gte)
   */
  private Long purchaseCodeGte;
  /**
   * 采购单号 比较(lt)
   */
  private Long purchaseCodeLt;
  /**
   * 采购单号 比较(lte)
   */
  private Long purchaseCodeLte;
  /**
   * 采购单号 比较(contains)
   */
  private Long purchaseCodeContains;
  /**
   * 采购单号 比较(notcontains)
   */
  private Long purchaseCodeNotcontains;
  /**
   * 采购单号 比较(startswith)
   */
  private Long purchaseCodeStartswith;
  /**
   * 采购单号 比较(endswith)
   */
  private Long purchaseCodeEndswith;
  /**
   * 采购单号 比较(isnull)
   */
  private Boolean purchaseCodeIsnull;
  /**
   * 采购单号 比较(isnotnull)
   */
  private Boolean purchaseCodeIsnotnull;
  /**
   * 采购单号的采购单号 比较(eq)
   */
  private String purchaseCodePurchaseOrderCodeEq;
  /**
   * 采购单号的采购单号 比较(neq)
   */
  private String purchaseCodePurchaseOrderCodeNeq;
  /**
   * 采购单号的采购单号 比较(gt)
   */
  private String purchaseCodePurchaseOrderCodeGt;
  /**
   * 采购单号的采购单号 比较(gte)
   */
  private String purchaseCodePurchaseOrderCodeGte;
  /**
   * 采购单号的采购单号 比较(lt)
   */
  private String purchaseCodePurchaseOrderCodeLt;
  /**
   * 采购单号的采购单号 比较(lte)
   */
  private String purchaseCodePurchaseOrderCodeLte;
  /**
   * 采购单号的采购单号 比较(contains)
   */
  private String purchaseCodePurchaseOrderCodeContains;
  /**
   * 采购单号的采购单号 比较(notcontains)
   */
  private String purchaseCodePurchaseOrderCodeNotcontains;
  /**
   * 采购单号的采购单号 比较(startswith)
   */
  private String purchaseCodePurchaseOrderCodeStartswith;
  /**
   * 采购单号的采购单号 比较(endswith)
   */
  private String purchaseCodePurchaseOrderCodeEndswith;
  /**
   * 采购单号的采购单号 比较(isnull)
   */
  private Boolean purchaseCodePurchaseOrderCodeIsnull;
  /**
   * 采购单号的采购单号 比较(isnotnull)
   */
  private Boolean purchaseCodePurchaseOrderCodeIsnotnull;

  /**
   * 采购单号(范围搜索)
   */
  private List<Long> purchaseCodeInList;

  /**
   * 采购员
   */
  private Long buyerName;

  /**
   * 采购员 比较(eq)
   */
  private Long buyerNameEq;
  /**
   * 采购员 比较(neq)
   */
  private Long buyerNameNeq;
  /**
   * 采购员 比较(gt)
   */
  private Long buyerNameGt;
  /**
   * 采购员 比较(gte)
   */
  private Long buyerNameGte;
  /**
   * 采购员 比较(lt)
   */
  private Long buyerNameLt;
  /**
   * 采购员 比较(lte)
   */
  private Long buyerNameLte;
  /**
   * 采购员 比较(contains)
   */
  private Long buyerNameContains;
  /**
   * 采购员 比较(notcontains)
   */
  private Long buyerNameNotcontains;
  /**
   * 采购员 比较(startswith)
   */
  private Long buyerNameStartswith;
  /**
   * 采购员 比较(endswith)
   */
  private Long buyerNameEndswith;
  /**
   * 采购员 比较(isnull)
   */
  private Boolean buyerNameIsnull;
  /**
   * 采购员 比较(isnotnull)
   */
  private Boolean buyerNameIsnotnull;
  /**
   * 采购员的显示用户名 比较(eq)
   */
  private String buyerNameNameEq;
  /**
   * 采购员的显示用户名 比较(neq)
   */
  private String buyerNameNameNeq;
  /**
   * 采购员的显示用户名 比较(gt)
   */
  private String buyerNameNameGt;
  /**
   * 采购员的显示用户名 比较(gte)
   */
  private String buyerNameNameGte;
  /**
   * 采购员的显示用户名 比较(lt)
   */
  private String buyerNameNameLt;
  /**
   * 采购员的显示用户名 比较(lte)
   */
  private String buyerNameNameLte;
  /**
   * 采购员的显示用户名 比较(contains)
   */
  private String buyerNameNameContains;
  /**
   * 采购员的显示用户名 比较(notcontains)
   */
  private String buyerNameNameNotcontains;
  /**
   * 采购员的显示用户名 比较(startswith)
   */
  private String buyerNameNameStartswith;
  /**
   * 采购员的显示用户名 比较(endswith)
   */
  private String buyerNameNameEndswith;
  /**
   * 采购员的显示用户名 比较(isnull)
   */
  private Boolean buyerNameNameIsnull;
  /**
   * 采购员的显示用户名 比较(isnotnull)
   */
  private Boolean buyerNameNameIsnotnull;

  /**
   * 采购员(范围搜索)
   */
  private List<Long> buyerNameInList;

  /**
   * 收货人
   */
  private Long receiveName;

  /**
   * 收货人 比较(eq)
   */
  private Long receiveNameEq;
  /**
   * 收货人 比较(neq)
   */
  private Long receiveNameNeq;
  /**
   * 收货人 比较(gt)
   */
  private Long receiveNameGt;
  /**
   * 收货人 比较(gte)
   */
  private Long receiveNameGte;
  /**
   * 收货人 比较(lt)
   */
  private Long receiveNameLt;
  /**
   * 收货人 比较(lte)
   */
  private Long receiveNameLte;
  /**
   * 收货人 比较(contains)
   */
  private Long receiveNameContains;
  /**
   * 收货人 比较(notcontains)
   */
  private Long receiveNameNotcontains;
  /**
   * 收货人 比较(startswith)
   */
  private Long receiveNameStartswith;
  /**
   * 收货人 比较(endswith)
   */
  private Long receiveNameEndswith;
  /**
   * 收货人 比较(isnull)
   */
  private Boolean receiveNameIsnull;
  /**
   * 收货人 比较(isnotnull)
   */
  private Boolean receiveNameIsnotnull;
  /**
   * 收货人的显示用户名 比较(eq)
   */
  private String receiveNameNameEq;
  /**
   * 收货人的显示用户名 比较(neq)
   */
  private String receiveNameNameNeq;
  /**
   * 收货人的显示用户名 比较(gt)
   */
  private String receiveNameNameGt;
  /**
   * 收货人的显示用户名 比较(gte)
   */
  private String receiveNameNameGte;
  /**
   * 收货人的显示用户名 比较(lt)
   */
  private String receiveNameNameLt;
  /**
   * 收货人的显示用户名 比较(lte)
   */
  private String receiveNameNameLte;
  /**
   * 收货人的显示用户名 比较(contains)
   */
  private String receiveNameNameContains;
  /**
   * 收货人的显示用户名 比较(notcontains)
   */
  private String receiveNameNameNotcontains;
  /**
   * 收货人的显示用户名 比较(startswith)
   */
  private String receiveNameNameStartswith;
  /**
   * 收货人的显示用户名 比较(endswith)
   */
  private String receiveNameNameEndswith;
  /**
   * 收货人的显示用户名 比较(isnull)
   */
  private Boolean receiveNameNameIsnull;
  /**
   * 收货人的显示用户名 比较(isnotnull)
   */
  private Boolean receiveNameNameIsnotnull;

  /**
   * 收货人(范围搜索)
   */
  private List<Long> receiveNameInList;

  /**
   * 仓库
   */
  private Long warehouse;

  /**
   * 仓库 比较(eq)
   */
  private Long warehouseEq;
  /**
   * 仓库 比较(neq)
   */
  private Long warehouseNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long warehouseGt;
  /**
   * 仓库 比较(gte)
   */
  private Long warehouseGte;
  /**
   * 仓库 比较(lt)
   */
  private Long warehouseLt;
  /**
   * 仓库 比较(lte)
   */
  private Long warehouseLte;
  /**
   * 仓库 比较(contains)
   */
  private Long warehouseContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long warehouseNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long warehouseStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long warehouseEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean warehouseIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean warehouseIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String warehouseNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String warehouseNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String warehouseNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String warehouseNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String warehouseNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String warehouseNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String warehouseNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String warehouseNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String warehouseNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String warehouseNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> warehouseInList;

  /**
   * 供应商
   */
  private Long supplier;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierInList;

  /**
   * 最早到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receiveTimeStart;

  /**
   * 最晚到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receiveTimeEnd;

  /**
   * 到货时间 比较(eq)
   */
  private Date receiveTimeEq;
  /**
   * 到货时间 比较(neq)
   */
  private Date receiveTimeNeq;
  /**
   * 到货时间 比较(gt)
   */
  private Date receiveTimeGt;
  /**
   * 到货时间 比较(gte)
   */
  private Date receiveTimeGte;
  /**
   * 到货时间 比较(lt)
   */
  private Date receiveTimeLt;
  /**
   * 到货时间 比较(lte)
   */
  private Date receiveTimeLte;
  /**
   * 到货时间 比较(contains)
   */
  private Date receiveTimeContains;
  /**
   * 到货时间 比较(notcontains)
   */
  private Date receiveTimeNotcontains;
  /**
   * 到货时间 比较(startswith)
   */
  private Date receiveTimeStartswith;
  /**
   * 到货时间 比较(endswith)
   */
  private Date receiveTimeEndswith;
  /**
   * 到货时间 比较(isnull)
   */
  private Boolean receiveTimeIsnull;
  /**
   * 到货时间 比较(isnotnull)
   */
  private Boolean receiveTimeIsnotnull;

  /**
   * 质检量
   */
  private Long productReceiveNum;

  /**
   * 最小质检量
   */
  private Long productReceiveNumMin;

  /**
   * 最大质检量
   */
  private Long productReceiveNumMax;

  /**
   * 质检量 比较(eq)
   */
  private Long productReceiveNumEq;
  /**
   * 质检量 比较(neq)
   */
  private Long productReceiveNumNeq;
  /**
   * 质检量 比较(gt)
   */
  private Long productReceiveNumGt;
  /**
   * 质检量 比较(gte)
   */
  private Long productReceiveNumGte;
  /**
   * 质检量 比较(lt)
   */
  private Long productReceiveNumLt;
  /**
   * 质检量 比较(lte)
   */
  private Long productReceiveNumLte;
  /**
   * 质检量 比较(contains)
   */
  private Long productReceiveNumContains;
  /**
   * 质检量 比较(notcontains)
   */
  private Long productReceiveNumNotcontains;
  /**
   * 质检量 比较(startswith)
   */
  private Long productReceiveNumStartswith;
  /**
   * 质检量 比较(endswith)
   */
  private Long productReceiveNumEndswith;
  /**
   * 质检量 比较(isnull)
   */
  private Boolean productReceiveNumIsnull;
  /**
   * 质检量 比较(isnotnull)
   */
  private Boolean productReceiveNumIsnotnull;

  /**
   * 质检方式
   */
  private String qcMethodType;

  /**
   * 质检方式 比较(eq)
   */
  private String qcMethodTypeEq;
  /**
   * 质检方式 比较(neq)
   */
  private String qcMethodTypeNeq;
  /**
   * 质检方式 比较(gt)
   */
  private String qcMethodTypeGt;
  /**
   * 质检方式 比较(gte)
   */
  private String qcMethodTypeGte;
  /**
   * 质检方式 比较(lt)
   */
  private String qcMethodTypeLt;
  /**
   * 质检方式 比较(lte)
   */
  private String qcMethodTypeLte;
  /**
   * 质检方式 比较(contains)
   */
  private String qcMethodTypeContains;
  /**
   * 质检方式 比较(notcontains)
   */
  private String qcMethodTypeNotcontains;
  /**
   * 质检方式 比较(startswith)
   */
  private String qcMethodTypeStartswith;
  /**
   * 质检方式 比较(endswith)
   */
  private String qcMethodTypeEndswith;
  /**
   * 质检方式 比较(isnull)
   */
  private Boolean qcMethodTypeIsnull;
  /**
   * 质检方式 比较(isnotnull)
   */
  private Boolean qcMethodTypeIsnotnull;

  /**
   * 质检方式(精确搜索)
   */
  private List<String> qcMethodTypeInList;

  /**
   * 抽检合格率
   */
  private java.math.BigDecimal qcRatePass;

  /**
   * 最小抽检合格率
   */
  private java.math.BigDecimal qcRatePassMin;

  /**
   * 最大抽检合格率
   */
  private java.math.BigDecimal qcRatePassMax;

  /**
   * 抽检合格率 比较(eq)
   */
  private java.math.BigDecimal qcRatePassEq;
  /**
   * 抽检合格率 比较(neq)
   */
  private java.math.BigDecimal qcRatePassNeq;
  /**
   * 抽检合格率 比较(gt)
   */
  private java.math.BigDecimal qcRatePassGt;
  /**
   * 抽检合格率 比较(gte)
   */
  private java.math.BigDecimal qcRatePassGte;
  /**
   * 抽检合格率 比较(lt)
   */
  private java.math.BigDecimal qcRatePassLt;
  /**
   * 抽检合格率 比较(lte)
   */
  private java.math.BigDecimal qcRatePassLte;
  /**
   * 抽检合格率 比较(contains)
   */
  private java.math.BigDecimal qcRatePassContains;
  /**
   * 抽检合格率 比较(notcontains)
   */
  private java.math.BigDecimal qcRatePassNotcontains;
  /**
   * 抽检合格率 比较(startswith)
   */
  private java.math.BigDecimal qcRatePassStartswith;
  /**
   * 抽检合格率 比较(endswith)
   */
  private java.math.BigDecimal qcRatePassEndswith;
  /**
   * 抽检合格率 比较(isnull)
   */
  private Boolean qcRatePassIsnull;
  /**
   * 抽检合格率 比较(isnotnull)
   */
  private Boolean qcRatePassIsnotnull;

  /**
   * 良品量
   */
  private Integer productGoodNum;

  /**
   * 最小良品量
   */
  private Integer productGoodNumMin;

  /**
   * 最大良品量
   */
  private Integer productGoodNumMax;

  /**
   * 良品量 比较(eq)
   */
  private Integer productGoodNumEq;
  /**
   * 良品量 比较(neq)
   */
  private Integer productGoodNumNeq;
  /**
   * 良品量 比较(gt)
   */
  private Integer productGoodNumGt;
  /**
   * 良品量 比较(gte)
   */
  private Integer productGoodNumGte;
  /**
   * 良品量 比较(lt)
   */
  private Integer productGoodNumLt;
  /**
   * 良品量 比较(lte)
   */
  private Integer productGoodNumLte;
  /**
   * 良品量 比较(contains)
   */
  private Integer productGoodNumContains;
  /**
   * 良品量 比较(notcontains)
   */
  private Integer productGoodNumNotcontains;
  /**
   * 良品量 比较(startswith)
   */
  private Integer productGoodNumStartswith;
  /**
   * 良品量 比较(endswith)
   */
  private Integer productGoodNumEndswith;
  /**
   * 良品量 比较(isnull)
   */
  private Boolean productGoodNumIsnull;
  /**
   * 良品量 比较(isnotnull)
   */
  private Boolean productGoodNumIsnotnull;

  /**
   * 次品量
   */
  private Integer productBadNum;

  /**
   * 最小次品量
   */
  private Integer productBadNumMin;

  /**
   * 最大次品量
   */
  private Integer productBadNumMax;

  /**
   * 次品量 比较(eq)
   */
  private Integer productBadNumEq;
  /**
   * 次品量 比较(neq)
   */
  private Integer productBadNumNeq;
  /**
   * 次品量 比较(gt)
   */
  private Integer productBadNumGt;
  /**
   * 次品量 比较(gte)
   */
  private Integer productBadNumGte;
  /**
   * 次品量 比较(lt)
   */
  private Integer productBadNumLt;
  /**
   * 次品量 比较(lte)
   */
  private Integer productBadNumLte;
  /**
   * 次品量 比较(contains)
   */
  private Integer productBadNumContains;
  /**
   * 次品量 比较(notcontains)
   */
  private Integer productBadNumNotcontains;
  /**
   * 次品量 比较(startswith)
   */
  private Integer productBadNumStartswith;
  /**
   * 次品量 比较(endswith)
   */
  private Integer productBadNumEndswith;
  /**
   * 次品量 比较(isnull)
   */
  private Boolean productBadNumIsnull;
  /**
   * 次品量 比较(isnotnull)
   */
  private Boolean productBadNumIsnotnull;

  /**
   * 质检员
   */
  private Long qcName;

  /**
   * 质检员 比较(eq)
   */
  private Long qcNameEq;
  /**
   * 质检员 比较(neq)
   */
  private Long qcNameNeq;
  /**
   * 质检员 比较(gt)
   */
  private Long qcNameGt;
  /**
   * 质检员 比较(gte)
   */
  private Long qcNameGte;
  /**
   * 质检员 比较(lt)
   */
  private Long qcNameLt;
  /**
   * 质检员 比较(lte)
   */
  private Long qcNameLte;
  /**
   * 质检员 比较(contains)
   */
  private Long qcNameContains;
  /**
   * 质检员 比较(notcontains)
   */
  private Long qcNameNotcontains;
  /**
   * 质检员 比较(startswith)
   */
  private Long qcNameStartswith;
  /**
   * 质检员 比较(endswith)
   */
  private Long qcNameEndswith;
  /**
   * 质检员 比较(isnull)
   */
  private Boolean qcNameIsnull;
  /**
   * 质检员 比较(isnotnull)
   */
  private Boolean qcNameIsnotnull;
  /**
   * 质检员的显示用户名 比较(eq)
   */
  private String qcNameNameEq;
  /**
   * 质检员的显示用户名 比较(neq)
   */
  private String qcNameNameNeq;
  /**
   * 质检员的显示用户名 比较(gt)
   */
  private String qcNameNameGt;
  /**
   * 质检员的显示用户名 比较(gte)
   */
  private String qcNameNameGte;
  /**
   * 质检员的显示用户名 比较(lt)
   */
  private String qcNameNameLt;
  /**
   * 质检员的显示用户名 比较(lte)
   */
  private String qcNameNameLte;
  /**
   * 质检员的显示用户名 比较(contains)
   */
  private String qcNameNameContains;
  /**
   * 质检员的显示用户名 比较(notcontains)
   */
  private String qcNameNameNotcontains;
  /**
   * 质检员的显示用户名 比较(startswith)
   */
  private String qcNameNameStartswith;
  /**
   * 质检员的显示用户名 比较(endswith)
   */
  private String qcNameNameEndswith;
  /**
   * 质检员的显示用户名 比较(isnull)
   */
  private Boolean qcNameNameIsnull;
  /**
   * 质检员的显示用户名 比较(isnotnull)
   */
  private Boolean qcNameNameIsnotnull;

  /**
   * 质检员(范围搜索)
   */
  private List<Long> qcNameInList;

  /**
   * 最早质检时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date qcTimeStart;

  /**
   * 最晚质检时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date qcTimeEnd;

  /**
   * 质检时间 比较(eq)
   */
  private Date qcTimeEq;
  /**
   * 质检时间 比较(neq)
   */
  private Date qcTimeNeq;
  /**
   * 质检时间 比较(gt)
   */
  private Date qcTimeGt;
  /**
   * 质检时间 比较(gte)
   */
  private Date qcTimeGte;
  /**
   * 质检时间 比较(lt)
   */
  private Date qcTimeLt;
  /**
   * 质检时间 比较(lte)
   */
  private Date qcTimeLte;
  /**
   * 质检时间 比较(contains)
   */
  private Date qcTimeContains;
  /**
   * 质检时间 比较(notcontains)
   */
  private Date qcTimeNotcontains;
  /**
   * 质检时间 比较(startswith)
   */
  private Date qcTimeStartswith;
  /**
   * 质检时间 比较(endswith)
   */
  private Date qcTimeEndswith;
  /**
   * 质检时间 比较(isnull)
   */
  private Boolean qcTimeIsnull;
  /**
   * 质检时间 比较(isnotnull)
   */
  private Boolean qcTimeIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 质检状态
   */
  private String qcStatus;

  /**
   * 质检状态 比较(eq)
   */
  private String qcStatusEq;
  /**
   * 质检状态 比较(neq)
   */
  private String qcStatusNeq;
  /**
   * 质检状态 比较(gt)
   */
  private String qcStatusGt;
  /**
   * 质检状态 比较(gte)
   */
  private String qcStatusGte;
  /**
   * 质检状态 比较(lt)
   */
  private String qcStatusLt;
  /**
   * 质检状态 比较(lte)
   */
  private String qcStatusLte;
  /**
   * 质检状态 比较(contains)
   */
  private String qcStatusContains;
  /**
   * 质检状态 比较(notcontains)
   */
  private String qcStatusNotcontains;
  /**
   * 质检状态 比较(startswith)
   */
  private String qcStatusStartswith;
  /**
   * 质检状态 比较(endswith)
   */
  private String qcStatusEndswith;
  /**
   * 质检状态 比较(isnull)
   */
  private Boolean qcStatusIsnull;
  /**
   * 质检状态 比较(isnotnull)
   */
  private Boolean qcStatusIsnotnull;

  /**
   * 质检状态(精确搜索)
   */
  private List<String> qcStatusInList;

  /**
   * 打印状态
   */
  private String isPrint;

  /**
   * 打印状态 比较(eq)
   */
  private String isPrintEq;
  /**
   * 打印状态 比较(neq)
   */
  private String isPrintNeq;
  /**
   * 打印状态 比较(gt)
   */
  private String isPrintGt;
  /**
   * 打印状态 比较(gte)
   */
  private String isPrintGte;
  /**
   * 打印状态 比较(lt)
   */
  private String isPrintLt;
  /**
   * 打印状态 比较(lte)
   */
  private String isPrintLte;
  /**
   * 打印状态 比较(contains)
   */
  private String isPrintContains;
  /**
   * 打印状态 比较(notcontains)
   */
  private String isPrintNotcontains;
  /**
   * 打印状态 比较(startswith)
   */
  private String isPrintStartswith;
  /**
   * 打印状态 比较(endswith)
   */
  private String isPrintEndswith;
  /**
   * 打印状态 比较(isnull)
   */
  private Boolean isPrintIsnull;
  /**
   * 打印状态 比较(isnotnull)
   */
  private Boolean isPrintIsnotnull;

  /**
   * 打印状态(精确搜索)
   */
  private List<String> isPrintInList;

  /**
   * 商品标签(模糊搜索)
   */
  private String productLabel;

  /**
   * 商品标签 比较(eq)
   */
  private String productLabelEq;
  /**
   * 商品标签 比较(neq)
   */
  private String productLabelNeq;
  /**
   * 商品标签 比较(gt)
   */
  private String productLabelGt;
  /**
   * 商品标签 比较(gte)
   */
  private String productLabelGte;
  /**
   * 商品标签 比较(lt)
   */
  private String productLabelLt;
  /**
   * 商品标签 比较(lte)
   */
  private String productLabelLte;
  /**
   * 商品标签 比较(contains)
   */
  private String productLabelContains;
  /**
   * 商品标签 比较(notcontains)
   */
  private String productLabelNotcontains;
  /**
   * 商品标签 比较(startswith)
   */
  private String productLabelStartswith;
  /**
   * 商品标签 比较(endswith)
   */
  private String productLabelEndswith;
  /**
   * 商品标签 比较(isnull)
   */
  private Boolean productLabelIsnull;
  /**
   * 商品标签 比较(isnotnull)
   */
  private Boolean productLabelIsnotnull;

  /**
   * 商品标签(精确搜索)
   */
  private List<String> productLabelInList;

  /**
   * 收货单号(模糊搜索)
   */
  private String deliveryOrderSn;

  /**
   * 收货单号 比较(eq)
   */
  private String deliveryOrderSnEq;
  /**
   * 收货单号 比较(neq)
   */
  private String deliveryOrderSnNeq;
  /**
   * 收货单号 比较(gt)
   */
  private String deliveryOrderSnGt;
  /**
   * 收货单号 比较(gte)
   */
  private String deliveryOrderSnGte;
  /**
   * 收货单号 比较(lt)
   */
  private String deliveryOrderSnLt;
  /**
   * 收货单号 比较(lte)
   */
  private String deliveryOrderSnLte;
  /**
   * 收货单号 比较(contains)
   */
  private String deliveryOrderSnContains;
  /**
   * 收货单号 比较(notcontains)
   */
  private String deliveryOrderSnNotcontains;
  /**
   * 收货单号 比较(startswith)
   */
  private String deliveryOrderSnStartswith;
  /**
   * 收货单号 比较(endswith)
   */
  private String deliveryOrderSnEndswith;
  /**
   * 收货单号 比较(isnull)
   */
  private Boolean deliveryOrderSnIsnull;
  /**
   * 收货单号 比较(isnotnull)
   */
  private Boolean deliveryOrderSnIsnotnull;

  /**
   * 收货单号(精确搜索)
   */
  private List<String> deliveryOrderSnInList;

  /**
   * 快捷入库下推
   */
  private Integer entryLibrary;

  /**
   * 最小快捷入库下推
   */
  private Integer entryLibraryMin;

  /**
   * 最大快捷入库下推
   */
  private Integer entryLibraryMax;

  /**
   * 快捷入库下推 比较(eq)
   */
  private Integer entryLibraryEq;
  /**
   * 快捷入库下推 比较(neq)
   */
  private Integer entryLibraryNeq;
  /**
   * 快捷入库下推 比较(gt)
   */
  private Integer entryLibraryGt;
  /**
   * 快捷入库下推 比较(gte)
   */
  private Integer entryLibraryGte;
  /**
   * 快捷入库下推 比较(lt)
   */
  private Integer entryLibraryLt;
  /**
   * 快捷入库下推 比较(lte)
   */
  private Integer entryLibraryLte;
  /**
   * 快捷入库下推 比较(contains)
   */
  private Integer entryLibraryContains;
  /**
   * 快捷入库下推 比较(notcontains)
   */
  private Integer entryLibraryNotcontains;
  /**
   * 快捷入库下推 比较(startswith)
   */
  private Integer entryLibraryStartswith;
  /**
   * 快捷入库下推 比较(endswith)
   */
  private Integer entryLibraryEndswith;
  /**
   * 快捷入库下推 比较(isnull)
   */
  private Boolean entryLibraryIsnull;
  /**
   * 快捷入库下推 比较(isnotnull)
   */
  private Boolean entryLibraryIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 目标表ID列(模糊搜索)
   */
  private String parentId;

  /**
   * 目标表ID列 比较(eq)
   */
  private String parentIdEq;
  /**
   * 目标表ID列 比较(neq)
   */
  private String parentIdNeq;
  /**
   * 目标表ID列 比较(gt)
   */
  private String parentIdGt;
  /**
   * 目标表ID列 比较(gte)
   */
  private String parentIdGte;
  /**
   * 目标表ID列 比较(lt)
   */
  private String parentIdLt;
  /**
   * 目标表ID列 比较(lte)
   */
  private String parentIdLte;
  /**
   * 目标表ID列 比较(contains)
   */
  private String parentIdContains;
  /**
   * 目标表ID列 比较(notcontains)
   */
  private String parentIdNotcontains;
  /**
   * 目标表ID列 比较(startswith)
   */
  private String parentIdStartswith;
  /**
   * 目标表ID列 比较(endswith)
   */
  private String parentIdEndswith;
  /**
   * 目标表ID列 比较(isnull)
   */
  private Boolean parentIdIsnull;
  /**
   * 目标表ID列 比较(isnotnull)
   */
  private Boolean parentIdIsnotnull;

  /**
   * 目标表ID列(精确搜索)
   */
  private List<String> parentIdInList;

  /**
   * 待检量
   */
  private Long noQcNum;

  /**
   * 最小待检量
   */
  private Long noQcNumMin;

  /**
   * 最大待检量
   */
  private Long noQcNumMax;

  /**
   * 待检量 比较(eq)
   */
  private Long noQcNumEq;
  /**
   * 待检量 比较(neq)
   */
  private Long noQcNumNeq;
  /**
   * 待检量 比较(gt)
   */
  private Long noQcNumGt;
  /**
   * 待检量 比较(gte)
   */
  private Long noQcNumGte;
  /**
   * 待检量 比较(lt)
   */
  private Long noQcNumLt;
  /**
   * 待检量 比较(lte)
   */
  private Long noQcNumLte;
  /**
   * 待检量 比较(contains)
   */
  private Long noQcNumContains;
  /**
   * 待检量 比较(notcontains)
   */
  private Long noQcNumNotcontains;
  /**
   * 待检量 比较(startswith)
   */
  private Long noQcNumStartswith;
  /**
   * 待检量 比较(endswith)
   */
  private Long noQcNumEndswith;
  /**
   * 待检量 比较(isnull)
   */
  private Boolean noQcNumIsnull;
  /**
   * 待检量 比较(isnotnull)
   */
  private Boolean noQcNumIsnotnull;

  /**
   * 抽检量
   */
  private Integer productQcNum;

  /**
   * 最小抽检量
   */
  private Integer productQcNumMin;

  /**
   * 最大抽检量
   */
  private Integer productQcNumMax;

  /**
   * 抽检量 比较(eq)
   */
  private Integer productQcNumEq;
  /**
   * 抽检量 比较(neq)
   */
  private Integer productQcNumNeq;
  /**
   * 抽检量 比较(gt)
   */
  private Integer productQcNumGt;
  /**
   * 抽检量 比较(gte)
   */
  private Integer productQcNumGte;
  /**
   * 抽检量 比较(lt)
   */
  private Integer productQcNumLt;
  /**
   * 抽检量 比较(lte)
   */
  private Integer productQcNumLte;
  /**
   * 抽检量 比较(contains)
   */
  private Integer productQcNumContains;
  /**
   * 抽检量 比较(notcontains)
   */
  private Integer productQcNumNotcontains;
  /**
   * 抽检量 比较(startswith)
   */
  private Integer productQcNumStartswith;
  /**
   * 抽检量 比较(endswith)
   */
  private Integer productQcNumEndswith;
  /**
   * 抽检量 比较(isnull)
   */
  private Boolean productQcNumIsnull;
  /**
   * 抽检量 比较(isnotnull)
   */
  private Boolean productQcNumIsnotnull;

  /**
   * 抽检次品量
   */
  private Integer qcBadNum;

  /**
   * 最小抽检次品量
   */
  private Integer qcBadNumMin;

  /**
   * 最大抽检次品量
   */
  private Integer qcBadNumMax;

  /**
   * 抽检次品量 比较(eq)
   */
  private Integer qcBadNumEq;
  /**
   * 抽检次品量 比较(neq)
   */
  private Integer qcBadNumNeq;
  /**
   * 抽检次品量 比较(gt)
   */
  private Integer qcBadNumGt;
  /**
   * 抽检次品量 比较(gte)
   */
  private Integer qcBadNumGte;
  /**
   * 抽检次品量 比较(lt)
   */
  private Integer qcBadNumLt;
  /**
   * 抽检次品量 比较(lte)
   */
  private Integer qcBadNumLte;
  /**
   * 抽检次品量 比较(contains)
   */
  private Integer qcBadNumContains;
  /**
   * 抽检次品量 比较(notcontains)
   */
  private Integer qcBadNumNotcontains;
  /**
   * 抽检次品量 比较(startswith)
   */
  private Integer qcBadNumStartswith;
  /**
   * 抽检次品量 比较(endswith)
   */
  private Integer qcBadNumEndswith;
  /**
   * 抽检次品量 比较(isnull)
   */
  private Boolean qcBadNumIsnull;
  /**
   * 抽检次品量 比较(isnotnull)
   */
  private Boolean qcBadNumIsnotnull;

  /**
   * 抽检比例
   */
  private java.math.BigDecimal qcRate;

  /**
   * 最小抽检比例
   */
  private java.math.BigDecimal qcRateMin;

  /**
   * 最大抽检比例
   */
  private java.math.BigDecimal qcRateMax;

  /**
   * 抽检比例 比较(eq)
   */
  private java.math.BigDecimal qcRateEq;
  /**
   * 抽检比例 比较(neq)
   */
  private java.math.BigDecimal qcRateNeq;
  /**
   * 抽检比例 比较(gt)
   */
  private java.math.BigDecimal qcRateGt;
  /**
   * 抽检比例 比较(gte)
   */
  private java.math.BigDecimal qcRateGte;
  /**
   * 抽检比例 比较(lt)
   */
  private java.math.BigDecimal qcRateLt;
  /**
   * 抽检比例 比较(lte)
   */
  private java.math.BigDecimal qcRateLte;
  /**
   * 抽检比例 比较(contains)
   */
  private java.math.BigDecimal qcRateContains;
  /**
   * 抽检比例 比较(notcontains)
   */
  private java.math.BigDecimal qcRateNotcontains;
  /**
   * 抽检比例 比较(startswith)
   */
  private java.math.BigDecimal qcRateStartswith;
  /**
   * 抽检比例 比较(endswith)
   */
  private java.math.BigDecimal qcRateEndswith;
  /**
   * 抽检比例 比较(isnull)
   */
  private Boolean qcRateIsnull;
  /**
   * 抽检比例 比较(isnotnull)
   */
  private Boolean qcRateIsnotnull;

  /**
   * 总良品量
   */
  private Integer allProductGoodNum;

  /**
   * 最小总良品量
   */
  private Integer allProductGoodNumMin;

  /**
   * 最大总良品量
   */
  private Integer allProductGoodNumMax;

  /**
   * 总良品量 比较(eq)
   */
  private Integer allProductGoodNumEq;
  /**
   * 总良品量 比较(neq)
   */
  private Integer allProductGoodNumNeq;
  /**
   * 总良品量 比较(gt)
   */
  private Integer allProductGoodNumGt;
  /**
   * 总良品量 比较(gte)
   */
  private Integer allProductGoodNumGte;
  /**
   * 总良品量 比较(lt)
   */
  private Integer allProductGoodNumLt;
  /**
   * 总良品量 比较(lte)
   */
  private Integer allProductGoodNumLte;
  /**
   * 总良品量 比较(contains)
   */
  private Integer allProductGoodNumContains;
  /**
   * 总良品量 比较(notcontains)
   */
  private Integer allProductGoodNumNotcontains;
  /**
   * 总良品量 比较(startswith)
   */
  private Integer allProductGoodNumStartswith;
  /**
   * 总良品量 比较(endswith)
   */
  private Integer allProductGoodNumEndswith;
  /**
   * 总良品量 比较(isnull)
   */
  private Boolean allProductGoodNumIsnull;
  /**
   * 总良品量 比较(isnotnull)
   */
  private Boolean allProductGoodNumIsnotnull;

  /**
   * 总次品量
   */
  private Integer allProductBadNum;

  /**
   * 最小总次品量
   */
  private Integer allProductBadNumMin;

  /**
   * 最大总次品量
   */
  private Integer allProductBadNumMax;

  /**
   * 总次品量 比较(eq)
   */
  private Integer allProductBadNumEq;
  /**
   * 总次品量 比较(neq)
   */
  private Integer allProductBadNumNeq;
  /**
   * 总次品量 比较(gt)
   */
  private Integer allProductBadNumGt;
  /**
   * 总次品量 比较(gte)
   */
  private Integer allProductBadNumGte;
  /**
   * 总次品量 比较(lt)
   */
  private Integer allProductBadNumLt;
  /**
   * 总次品量 比较(lte)
   */
  private Integer allProductBadNumLte;
  /**
   * 总次品量 比较(contains)
   */
  private Integer allProductBadNumContains;
  /**
   * 总次品量 比较(notcontains)
   */
  private Integer allProductBadNumNotcontains;
  /**
   * 总次品量 比较(startswith)
   */
  private Integer allProductBadNumStartswith;
  /**
   * 总次品量 比较(endswith)
   */
  private Integer allProductBadNumEndswith;
  /**
   * 总次品量 比较(isnull)
   */
  private Boolean allProductBadNumIsnull;
  /**
   * 总次品量 比较(isnotnull)
   */
  private Boolean allProductBadNumIsnotnull;

  /**
   * 可用仓位
   */
  private Long whbCodeGoodId;

  /**
   * 可用仓位 比较(eq)
   */
  private Long whbCodeGoodIdEq;
  /**
   * 可用仓位 比较(neq)
   */
  private Long whbCodeGoodIdNeq;
  /**
   * 可用仓位 比较(gt)
   */
  private Long whbCodeGoodIdGt;
  /**
   * 可用仓位 比较(gte)
   */
  private Long whbCodeGoodIdGte;
  /**
   * 可用仓位 比较(lt)
   */
  private Long whbCodeGoodIdLt;
  /**
   * 可用仓位 比较(lte)
   */
  private Long whbCodeGoodIdLte;
  /**
   * 可用仓位 比较(contains)
   */
  private Long whbCodeGoodIdContains;
  /**
   * 可用仓位 比较(notcontains)
   */
  private Long whbCodeGoodIdNotcontains;
  /**
   * 可用仓位 比较(startswith)
   */
  private Long whbCodeGoodIdStartswith;
  /**
   * 可用仓位 比较(endswith)
   */
  private Long whbCodeGoodIdEndswith;
  /**
   * 可用仓位 比较(isnull)
   */
  private Boolean whbCodeGoodIdIsnull;
  /**
   * 可用仓位 比较(isnotnull)
   */
  private Boolean whbCodeGoodIdIsnotnull;
  /**
   * 可用仓位的仓位 比较(eq)
   */
  private String whbCodeGoodIdStorageBinEq;
  /**
   * 可用仓位的仓位 比较(neq)
   */
  private String whbCodeGoodIdStorageBinNeq;
  /**
   * 可用仓位的仓位 比较(gt)
   */
  private String whbCodeGoodIdStorageBinGt;
  /**
   * 可用仓位的仓位 比较(gte)
   */
  private String whbCodeGoodIdStorageBinGte;
  /**
   * 可用仓位的仓位 比较(lt)
   */
  private String whbCodeGoodIdStorageBinLt;
  /**
   * 可用仓位的仓位 比较(lte)
   */
  private String whbCodeGoodIdStorageBinLte;
  /**
   * 可用仓位的仓位 比较(contains)
   */
  private String whbCodeGoodIdStorageBinContains;
  /**
   * 可用仓位的仓位 比较(notcontains)
   */
  private String whbCodeGoodIdStorageBinNotcontains;
  /**
   * 可用仓位的仓位 比较(startswith)
   */
  private String whbCodeGoodIdStorageBinStartswith;
  /**
   * 可用仓位的仓位 比较(endswith)
   */
  private String whbCodeGoodIdStorageBinEndswith;
  /**
   * 可用仓位的仓位 比较(isnull)
   */
  private Boolean whbCodeGoodIdStorageBinIsnull;
  /**
   * 可用仓位的仓位 比较(isnotnull)
   */
  private Boolean whbCodeGoodIdStorageBinIsnotnull;

  /**
   * 可用仓位(范围搜索)
   */
  private List<Long> whbCodeGoodIdInList;

  /**
   * 次品仓位
   */
  private Long whbCodeBadId;

  /**
   * 次品仓位 比较(eq)
   */
  private Long whbCodeBadIdEq;
  /**
   * 次品仓位 比较(neq)
   */
  private Long whbCodeBadIdNeq;
  /**
   * 次品仓位 比较(gt)
   */
  private Long whbCodeBadIdGt;
  /**
   * 次品仓位 比较(gte)
   */
  private Long whbCodeBadIdGte;
  /**
   * 次品仓位 比较(lt)
   */
  private Long whbCodeBadIdLt;
  /**
   * 次品仓位 比较(lte)
   */
  private Long whbCodeBadIdLte;
  /**
   * 次品仓位 比较(contains)
   */
  private Long whbCodeBadIdContains;
  /**
   * 次品仓位 比较(notcontains)
   */
  private Long whbCodeBadIdNotcontains;
  /**
   * 次品仓位 比较(startswith)
   */
  private Long whbCodeBadIdStartswith;
  /**
   * 次品仓位 比较(endswith)
   */
  private Long whbCodeBadIdEndswith;
  /**
   * 次品仓位 比较(isnull)
   */
  private Boolean whbCodeBadIdIsnull;
  /**
   * 次品仓位 比较(isnotnull)
   */
  private Boolean whbCodeBadIdIsnotnull;
  /**
   * 次品仓位的仓位 比较(eq)
   */
  private String whbCodeBadIdStorageBinEq;
  /**
   * 次品仓位的仓位 比较(neq)
   */
  private String whbCodeBadIdStorageBinNeq;
  /**
   * 次品仓位的仓位 比较(gt)
   */
  private String whbCodeBadIdStorageBinGt;
  /**
   * 次品仓位的仓位 比较(gte)
   */
  private String whbCodeBadIdStorageBinGte;
  /**
   * 次品仓位的仓位 比较(lt)
   */
  private String whbCodeBadIdStorageBinLt;
  /**
   * 次品仓位的仓位 比较(lte)
   */
  private String whbCodeBadIdStorageBinLte;
  /**
   * 次品仓位的仓位 比较(contains)
   */
  private String whbCodeBadIdStorageBinContains;
  /**
   * 次品仓位的仓位 比较(notcontains)
   */
  private String whbCodeBadIdStorageBinNotcontains;
  /**
   * 次品仓位的仓位 比较(startswith)
   */
  private String whbCodeBadIdStorageBinStartswith;
  /**
   * 次品仓位的仓位 比较(endswith)
   */
  private String whbCodeBadIdStorageBinEndswith;
  /**
   * 次品仓位的仓位 比较(isnull)
   */
  private Boolean whbCodeBadIdStorageBinIsnull;
  /**
   * 次品仓位的仓位 比较(isnotnull)
   */
  private Boolean whbCodeBadIdStorageBinIsnotnull;

  /**
   * 次品仓位(范围搜索)
   */
  private List<Long> whbCodeBadIdInList;

  /**
   * 是否有 质检图片
   */
  private Boolean qcImg;

  /**
   * 是否有 质检附件
   */
  private Boolean attachment;

  /**
   * 收货单子表ID
   */
  private Long receiptProductId;

  /**
   * 收货单子表ID 比较(eq)
   */
  private Long receiptProductIdEq;
  /**
   * 收货单子表ID 比较(neq)
   */
  private Long receiptProductIdNeq;
  /**
   * 收货单子表ID 比较(gt)
   */
  private Long receiptProductIdGt;
  /**
   * 收货单子表ID 比较(gte)
   */
  private Long receiptProductIdGte;
  /**
   * 收货单子表ID 比较(lt)
   */
  private Long receiptProductIdLt;
  /**
   * 收货单子表ID 比较(lte)
   */
  private Long receiptProductIdLte;
  /**
   * 收货单子表ID 比较(contains)
   */
  private Long receiptProductIdContains;
  /**
   * 收货单子表ID 比较(notcontains)
   */
  private Long receiptProductIdNotcontains;
  /**
   * 收货单子表ID 比较(startswith)
   */
  private Long receiptProductIdStartswith;
  /**
   * 收货单子表ID 比较(endswith)
   */
  private Long receiptProductIdEndswith;
  /**
   * 收货单子表ID 比较(isnull)
   */
  private Boolean receiptProductIdIsnull;
  /**
   * 收货单子表ID 比较(isnotnull)
   */
  private Boolean receiptProductIdIsnotnull;
  /**
   * 收货单子表ID的SKU 比较(eq)
   */
  private String receiptProductIdSkuEq;
  /**
   * 收货单子表ID的SKU 比较(neq)
   */
  private String receiptProductIdSkuNeq;
  /**
   * 收货单子表ID的SKU 比较(gt)
   */
  private String receiptProductIdSkuGt;
  /**
   * 收货单子表ID的SKU 比较(gte)
   */
  private String receiptProductIdSkuGte;
  /**
   * 收货单子表ID的SKU 比较(lt)
   */
  private String receiptProductIdSkuLt;
  /**
   * 收货单子表ID的SKU 比较(lte)
   */
  private String receiptProductIdSkuLte;
  /**
   * 收货单子表ID的SKU 比较(contains)
   */
  private String receiptProductIdSkuContains;
  /**
   * 收货单子表ID的SKU 比较(notcontains)
   */
  private String receiptProductIdSkuNotcontains;
  /**
   * 收货单子表ID的SKU 比较(startswith)
   */
  private String receiptProductIdSkuStartswith;
  /**
   * 收货单子表ID的SKU 比较(endswith)
   */
  private String receiptProductIdSkuEndswith;
  /**
   * 收货单子表ID的SKU 比较(isnull)
   */
  private Boolean receiptProductIdSkuIsnull;
  /**
   * 收货单子表ID的SKU 比较(isnotnull)
   */
  private Boolean receiptProductIdSkuIsnotnull;

  /**
   * 收货单子表ID(范围搜索)
   */
  private List<Long> receiptProductIdInList;

  /**
   * 收货单号(模糊搜索)
   */
  private String orderSn;

  /**
   * 收货单号 比较(eq)
   */
  private String orderSnEq;
  /**
   * 收货单号 比较(neq)
   */
  private String orderSnNeq;
  /**
   * 收货单号 比较(gt)
   */
  private String orderSnGt;
  /**
   * 收货单号 比较(gte)
   */
  private String orderSnGte;
  /**
   * 收货单号 比较(lt)
   */
  private String orderSnLt;
  /**
   * 收货单号 比较(lte)
   */
  private String orderSnLte;
  /**
   * 收货单号 比较(contains)
   */
  private String orderSnContains;
  /**
   * 收货单号 比较(notcontains)
   */
  private String orderSnNotcontains;
  /**
   * 收货单号 比较(startswith)
   */
  private String orderSnStartswith;
  /**
   * 收货单号 比较(endswith)
   */
  private String orderSnEndswith;
  /**
   * 收货单号 比较(isnull)
   */
  private Boolean orderSnIsnull;
  /**
   * 收货单号 比较(isnotnull)
   */
  private Boolean orderSnIsnotnull;

  /**
   * 收货单号(精确搜索)
   */
  private List<String> orderSnInList;

  /**
   * 单据状态
   */
  private String status;

  /**
   * 单据状态 比较(eq)
   */
  private String statusEq;
  /**
   * 单据状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 单据状态 比较(gt)
   */
  private String statusGt;
  /**
   * 单据状态 比较(gte)
   */
  private String statusGte;
  /**
   * 单据状态 比较(lt)
   */
  private String statusLt;
  /**
   * 单据状态 比较(lte)
   */
  private String statusLte;
  /**
   * 单据状态 比较(contains)
   */
  private String statusContains;
  /**
   * 单据状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 单据状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 单据状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 单据状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 单据状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 单据状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 是否有 上传图片
   */
  private Boolean uploadPictures;

  /**
   * 待检
   */
  private Long waitInspection;

  /**
   * 待检 比较(eq)
   */
  private Long waitInspectionEq;
  /**
   * 待检 比较(neq)
   */
  private Long waitInspectionNeq;
  /**
   * 待检 比较(gt)
   */
  private Long waitInspectionGt;
  /**
   * 待检 比较(gte)
   */
  private Long waitInspectionGte;
  /**
   * 待检 比较(lt)
   */
  private Long waitInspectionLt;
  /**
   * 待检 比较(lte)
   */
  private Long waitInspectionLte;
  /**
   * 待检 比较(contains)
   */
  private Long waitInspectionContains;
  /**
   * 待检 比较(notcontains)
   */
  private Long waitInspectionNotcontains;
  /**
   * 待检 比较(startswith)
   */
  private Long waitInspectionStartswith;
  /**
   * 待检 比较(endswith)
   */
  private Long waitInspectionEndswith;
  /**
   * 待检 比较(isnull)
   */
  private Boolean waitInspectionIsnull;
  /**
   * 待检 比较(isnotnull)
   */
  private Boolean waitInspectionIsnotnull;
  /**
   * 待检的仓位 比较(eq)
   */
  private String waitInspectionStorageBinEq;
  /**
   * 待检的仓位 比较(neq)
   */
  private String waitInspectionStorageBinNeq;
  /**
   * 待检的仓位 比较(gt)
   */
  private String waitInspectionStorageBinGt;
  /**
   * 待检的仓位 比较(gte)
   */
  private String waitInspectionStorageBinGte;
  /**
   * 待检的仓位 比较(lt)
   */
  private String waitInspectionStorageBinLt;
  /**
   * 待检的仓位 比较(lte)
   */
  private String waitInspectionStorageBinLte;
  /**
   * 待检的仓位 比较(contains)
   */
  private String waitInspectionStorageBinContains;
  /**
   * 待检的仓位 比较(notcontains)
   */
  private String waitInspectionStorageBinNotcontains;
  /**
   * 待检的仓位 比较(startswith)
   */
  private String waitInspectionStorageBinStartswith;
  /**
   * 待检的仓位 比较(endswith)
   */
  private String waitInspectionStorageBinEndswith;
  /**
   * 待检的仓位 比较(isnull)
   */
  private Boolean waitInspectionStorageBinIsnull;
  /**
   * 待检的仓位 比较(isnotnull)
   */
  private Boolean waitInspectionStorageBinIsnotnull;

  /**
   * 待检(范围搜索)
   */
  private List<Long> waitInspectionInList;

  /**
   * 加急
   */
  private String isUrgent;

  /**
   * 加急 比较(eq)
   */
  private String isUrgentEq;
  /**
   * 加急 比较(neq)
   */
  private String isUrgentNeq;
  /**
   * 加急 比较(gt)
   */
  private String isUrgentGt;
  /**
   * 加急 比较(gte)
   */
  private String isUrgentGte;
  /**
   * 加急 比较(lt)
   */
  private String isUrgentLt;
  /**
   * 加急 比较(lte)
   */
  private String isUrgentLte;
  /**
   * 加急 比较(contains)
   */
  private String isUrgentContains;
  /**
   * 加急 比较(notcontains)
   */
  private String isUrgentNotcontains;
  /**
   * 加急 比较(startswith)
   */
  private String isUrgentStartswith;
  /**
   * 加急 比较(endswith)
   */
  private String isUrgentEndswith;
  /**
   * 加急 比较(isnull)
   */
  private Boolean isUrgentIsnull;
  /**
   * 加急 比较(isnotnull)
   */
  private Boolean isUrgentIsnotnull;

  /**
   * 加急(精确搜索)
   */
  private List<String> isUrgentInList;

  /**
   * 模板id(模糊搜索)
   */
  private String classifyId;

  /**
   * 模板id 比较(eq)
   */
  private String classifyIdEq;
  /**
   * 模板id 比较(neq)
   */
  private String classifyIdNeq;
  /**
   * 模板id 比较(gt)
   */
  private String classifyIdGt;
  /**
   * 模板id 比较(gte)
   */
  private String classifyIdGte;
  /**
   * 模板id 比较(lt)
   */
  private String classifyIdLt;
  /**
   * 模板id 比较(lte)
   */
  private String classifyIdLte;
  /**
   * 模板id 比较(contains)
   */
  private String classifyIdContains;
  /**
   * 模板id 比较(notcontains)
   */
  private String classifyIdNotcontains;
  /**
   * 模板id 比较(startswith)
   */
  private String classifyIdStartswith;
  /**
   * 模板id 比较(endswith)
   */
  private String classifyIdEndswith;
  /**
   * 模板id 比较(isnull)
   */
  private Boolean classifyIdIsnull;
  /**
   * 模板id 比较(isnotnull)
   */
  private Boolean classifyIdIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
